package arr

// 你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

// 你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

// 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
// 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
// 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
// 给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

func totalFruit(in []int) int {
	var maxCount, left = 0, 0
	furitMap := make(map[int]int, 0)
	for right, value := range in {
		furitMap[value]++
		for len(furitMap) > 2 {
			furitMap[in[left]]--
			if furitMap[in[left]] == 0 {
				delete(furitMap, in[left])
			}
			left++
		}
		if right-left+1 > maxCount {
			maxCount = right - left + 1
		}
	}
	return maxCount

}

func totalFruitI(in []int) int {
	fruitMap := make(map[int]int)
	left, maxCount := 0, 0
	for right, val := range in {
		fruitMap[val]++
		for len(fruitMap) >= 2 {
			fruitMap[in[left]]--
			if fruitMap[in[left]] == 0 {
				delete(fruitMap, in[left])
			}
			left++
		}
		if right-left+1 > maxCount {
			maxCount = right - left + 1
		}
	}
	return maxCount
}

// 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

// 注意：

// 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
// 如果 s 中存在这样的子串，我们保证它是唯一的答案。

// 给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

// 示例:

// 输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

// getSpiralArr 获取螺旋数组
func getSpiralArr(in int) interface{} {
	res := make(map[int]map[int]int, 0)
	if in == 1 {
		res[0][0] = 1
		return res
	}
	// 00
	// 00 11
	// 00 11 22
	// 00 11 22 33
	// 00 11 22 33 44
	originSlice := make([][]int, 0)
	start := 0
	for end := in - 1; end >= start; end-- {
		sortSlice := make([][]int, 0)
		for idx := 0; idx <= end; idx++ {
			// 00 01 02 03
			sortSlice = append(sortSlice, []int{start, idx})
		}
		// 13 23 33
		for colDx := 1; colDx <= end; colDx++ {
			sortSlice = append(sortSlice, []int{colDx, end})
		}
		// 32 31 30 20 10 00
		tempSlice := sortSlice
		for key := len(tempSlice) - 2; key > 0; key-- {
			reverseSlice := tempSlice[key]
			sortSlice = append(sortSlice, []int{reverseSlice[1], reverseSlice[0]})
		}
		for _, value := range sortSlice {
			originSlice = append(originSlice, value)
		}
		start++
	}
	originIn := 1
	for _, resValue := range originSlice {
		_, ok := res[resValue[0]]
		if !ok {
			res[resValue[0]] = make(map[int]int)
		}
		_, okI := res[resValue[0]][resValue[1]]
		if okI {
			continue
		}
		res[resValue[0]][resValue[1]] = originIn
		originIn = originIn + 1
	}
	result := make([][]int, 0)
	for idx := 0; idx < in; idx++ {
		tempRes := make([]int, 0)
		for col := 0; col < in; col++ {
			tempValue := res[idx][col]
			tempRes = append(tempRes, tempValue)
		}
		result = append(result, tempRes)
	}
	return result
}
